home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / commands / manip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  5.4 KB  |  276 lines
  1. /*
  2.  * manip.c --
  3.  *    POSTGRES "manipulation" utility code.
  4.  */
  5.  
  6. #include "tmp/postgres.h"
  7.  
  8. RcsId("$Header: /private/postgres/src/commands/RCS/manip.c,v 1.5 1990/12/20 16:21:22 kemnitz Exp $");
  9.  
  10. #include "nodes/pg_lisp.h"
  11. #include "utils/log.h"    /* for elog, WARN */
  12.  
  13. #include "manip.h"
  14.  
  15. #define StringComputeLength(string)    (strlen(string))
  16.  
  17. LispValue
  18. DefineListRemoveOptionalIndicator(assocListInOutP, string)
  19.     LispValue    *assocListInOutP;
  20.     String        string;
  21. {
  22.     LispValue    entry;
  23.  
  24.     entry = LispRemoveMatchingString(assocListInOutP, string);
  25.  
  26.     if (!null(entry)) {
  27.         if (length(entry) != 1) {
  28.             if (length(entry) == 2) {
  29.                 elog(WARN, "Define: %s takes no argument",
  30.                     string);
  31.             } else {
  32.                 elog(WARN, "Define: parser error on %s",
  33.                     string);
  34.             }
  35.         }
  36.     }
  37.     return (entry);
  38. }
  39.  
  40. LispValue
  41. DefineListRemoveOptionalAssignment(assocListInOutP, string)
  42.     LispValue    *assocListInOutP;
  43.     String        string;
  44. {
  45.     LispValue    entry;
  46.  
  47.     entry = LispRemoveMatchingString(assocListInOutP, string);
  48.  
  49.     if (!null(entry)) {
  50.         if (length(entry) != 2) {
  51.             if (length(entry) == 1) {
  52.                 elog(WARN, "Define: %s requires an argument",
  53.                     string);
  54.             } else {
  55.                 elog(WARN, "Define: parser error on %s",
  56.                     string);
  57.             }
  58.         }
  59.     }
  60.     return (entry);
  61. }
  62.  
  63. LispValue
  64. DefineListRemoveRequiredAssignment(assocListInOutP, string)
  65.     LispValue    *assocListInOutP;
  66.     String        string;
  67. {
  68.     LispValue    entry;
  69.  
  70.     entry = LispRemoveMatchingString(assocListInOutP, string);
  71.     if (null(entry)) {
  72.         elog(WARN, "Define: %s unspecified", string);
  73.     }
  74.     if (length(entry) != 2) {
  75.         if (length(entry) == 1) {
  76.             elog(WARN, "Define: %s requires an argument", string);
  77.         } else {
  78.             elog(WARN, "Define: parser error on %s", string);
  79.         }
  80.     }
  81.  
  82.     return (entry);
  83. }
  84.  
  85. String
  86. DefineEntryGetString(entry)
  87.     LispValue    entry;
  88. {
  89.     AssertArg(consp(entry) && consp(CDR(entry)));
  90.  
  91.     if (!lispStringp(CADR(entry))) {
  92.         AssertArg(lispStringp(CAR(entry)));
  93.         elog(WARN, "Define: %s = what?", CString(CAR(entry)));
  94.     }
  95.  
  96.     return (CString(CADR(entry)));
  97. }
  98.  
  99. Name
  100. DefineEntryGetName(entry)
  101.     LispValue    entry;
  102. {
  103.     String    string;
  104.  
  105.     AssertArg(consp(entry) && consp(CDR(entry)));
  106.  
  107.     if (!lispStringp(CADR(entry))) {
  108.         AssertArg(lispStringp(CAR(entry)));
  109.         elog(WARN, "Define: %s = what?", CString(CAR(entry)));
  110.     }
  111.  
  112.     string = CString(CADR(entry));
  113.     if (StringComputeLength(string) >= 17) {
  114.         elog(WARN, "Define: %s is too long to be a name", string);
  115.     }
  116.  
  117.     return ((Name)string);
  118. }
  119.  
  120. int32
  121. DefineEntryGetInteger(entry)
  122.     LispValue    entry;
  123. {
  124.     AssertArg(consp(entry) && consp(CDR(entry)));
  125.  
  126.     if (!lispIntegerp(CADR(entry))) {
  127.         AssertArg(lispStringp(CAR(entry)));
  128.         elog(WARN, "Define: %s = what?", CString(CAR(entry)));
  129.     }
  130.  
  131.     return (CInteger(CADR(entry)));
  132. }
  133.  
  134. int16
  135. DefineEntryGetLength(entry)
  136.     LispValue    entry;
  137. {
  138.     int16    length;
  139.  
  140.     AssertArg(consp(entry) && consp(CDR(entry)));
  141.  
  142.     if (lispStringp(CADR(entry))) {
  143.         if (!StringEquals(CString(CADR(entry)), "variable")) {
  144.             AssertArg(lispStringp(CAR(entry)));
  145.             elog(WARN, "Define: %s = %s?", CString(CAR(entry)),
  146.                 CString(CADR(entry)));
  147.         }
  148.         length = -1;
  149.     } else if (!lispIntegerp(CADR(entry))) {
  150.         AssertArg(lispStringp(CAR(entry)));
  151.         elog(WARN, "Define: %s = what?", CString(CADR(entry)));
  152.     } else {
  153.         if (CInteger(CADR(entry)) < 0) {
  154.             elog(WARN, "Define: non-positive lengths disallowed");
  155.         }
  156.         length = CInteger(CADR(entry));
  157.     }
  158.  
  159.     return (length);
  160. }
  161.  
  162. void
  163. DefineListAssertEmpty(assocList)
  164.     LispValue    assocList;
  165. {
  166.     AssertArg(listp(assocList));
  167.  
  168.     if (!null(assocList)) {
  169.         if (lispStringp(CAR(CAR(assocList)))) {
  170.             elog(WARN, "Define: %s is unknown or repeated",
  171.                 CString(CAR(CAR(assocList))));
  172.         } else if (lispAtomp(CAR(CAR(assocList)))) {
  173.             elog(WARN, "Define: symbol %d is unknown or repeated",
  174.                 CAtom(CAR(CAR(assocList))));
  175.         } else {
  176.             elog(WARN, "Define: strange parse");
  177.         }
  178.     }
  179. }
  180.  
  181. /*
  182.  * private?
  183.  */
  184.  
  185. LispValue
  186. LispRemoveMatchingString(assocListInOutP, string)
  187.     LispValue    *assocListInOutP;
  188.     String        string;
  189. {
  190.     LispValue    rest;
  191.  
  192.     AssertArg(PointerIsValid(assocListInOutP));
  193.     AssertArg(listp(*assocListInOutP));
  194.     AssertArg(StringIsValid(string));
  195.  
  196.     if (null(*assocListInOutP)) {
  197.         return (LispNil);
  198.     }
  199.     rest = *assocListInOutP;
  200.     if (stringp(CAR(CAR(rest))) &&
  201.             StringEquals(CString(CAR(CAR(rest))), string)) {
  202.         *assocListInOutP = CDR(rest);
  203.         /*
  204.          * rplacd(rest, LispNil);
  205.          * freeit(rest);
  206.          */
  207.         return (CAR(rest));
  208.     }
  209.  
  210.     while (!null(CDR(rest))) {
  211.         /*
  212.          * process next element
  213.          */
  214.         if (stringp(CAR(CADR(rest))) &&
  215.                 StringEquals(CString(CAR(CADR(rest))),
  216.                     string)) {
  217.             LispValue    result;
  218.  
  219.             result = CDR(rest);
  220.             rplacd(rest, CDR(result));
  221.             /*
  222.              * rplacd(result, LispNil);
  223.              * freeit(result);
  224.              */
  225.             return (CAR(result));
  226.         }
  227.         rest = CDR(rest);
  228.     }
  229.     return (LispNil);
  230. }
  231.  
  232. LispValue
  233. LispRemoveMatchingSymbol(assocListInOutP, symbol)
  234.     LispValue    *assocListInOutP;
  235.     int        symbol;
  236. {
  237.     LispValue    rest;
  238.  
  239.     AssertArg(PointerIsValid(assocListInOutP));
  240.     AssertArg(listp(*assocListInOutP));
  241.     /* AssertArg(atom(symbol)); */
  242.  
  243.     if (null(*assocListInOutP)) {
  244.         return (LispNil);
  245.     }
  246.     rest = *assocListInOutP;
  247.     if (atom(CAR(CAR(rest))) && (CAtom(CAR(CAR(rest))) == symbol)) {
  248.         *assocListInOutP = CDR(rest);
  249.         /*
  250.          * rplacd(rest, LispNil);
  251.          * freeit(rest);
  252.          */
  253.         return (CAR(rest));
  254.     }
  255.  
  256.     while (!null(CDR(rest))) {
  257.         /*
  258.          * process next element
  259.          */
  260.         if (atom(CAR(CADR(rest))) &&
  261.                 (CAtom(CAR(CADR(rest))) == symbol)) {
  262.             LispValue    result;
  263.  
  264.             result = CDR(rest);
  265.             rplacd(rest, CDR(result));
  266.             /*
  267.              * rplacd(result, LispNil);
  268.              * freeit(result);
  269.              */
  270.             return (CAR(result));
  271.         }
  272.         rest = CDR(rest);
  273.     }
  274.     return (LispNil);
  275. }
  276.